home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / ABUSESRC.ZIP / AbuseSrc / abuse / src / objects.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-04-11  |  37.4 KB  |  1,636 lines
  1. #include "timage.hpp"
  2. #include "objects.hpp"
  3. #include "chars.hpp"
  4.  
  5. #include "game.hpp"
  6. #include "intsect.hpp"
  7. #include "ability.hpp"
  8. #include "lisp.hpp"
  9. #include "jrand.hpp"
  10. #include "light.hpp"
  11. #include "dprint.hpp"
  12. #include "clisp.hpp"
  13. #include "lisp_gc.hpp"
  14. #include "profile.hpp"
  15.  
  16. #ifdef SCADALISP
  17. #define LCAR(x)        CAR(x)
  18. #define LCDR(x)        CDR(x)
  19. #else
  20. #define LCAR(x)        (x)->car
  21. #define LCDR(x)        (x)->cdr
  22. #endif /* SCADALISP */
  23.  
  24. char **object_names;
  25. int total_objects;
  26. game_object *current_object;
  27. view *current_view;
  28.  
  29. game_object *game_object::copy()
  30. {
  31.   game_object *o=create(otype,x,y);
  32.   o->state=state;
  33.   int i=0;
  34.   for (;i<TOTAL_OBJECT_VARS;i++)
  35.     o->set_var(i,get_var(i));
  36.   memcpy(o->lvars,lvars,4*figures[otype]->tv);
  37.   for (i=0;i<total_objects();i++)
  38.     o->add_object(get_object(i));
  39.   for (i=0;i<total_lights();i++)
  40.     o->add_light(get_light(i));
  41.   return o;
  42. }
  43.  
  44. int simple_object::total_vars() { return TOTAL_OBJECT_VARS; }
  45.  
  46.  
  47. obj_desc object_descriptions[TOTAL_OBJECT_VARS]={
  48.                 {"fade_dir",      RC_C },
  49.                 {"frame_dir",     RC_C },
  50.                 {"direction",     RC_C },
  51.                 {"gravity_on",    RC_C },
  52.                 {"fade_count",    RC_C },
  53.  
  54.                 {"fade_max",      RC_C },
  55.                 {"active",        RC_C },
  56.                 {"flags",         RC_C },
  57.                 {"aitype",        RC_C },
  58.                 {"xvel",          RC_L },
  59.  
  60.                 {"fxvel",         RC_C },
  61.                 {"yvel",          RC_L },
  62.                 {"fyvel",         RC_C },
  63.                 {"xacel",         RC_L },
  64.                 {"fxacel",        RC_C },
  65.  
  66.                 {"yacel",         RC_L },
  67.                 {"fyacel",        RC_C },
  68.                 {"x",             RC_L },
  69.                 {"fx",            RC_C },
  70.                 {"y",             RC_L },
  71.  
  72.                 {"fy",            RC_C },
  73.                 {"hp",            RC_S },
  74.                 {"mp",            RC_S },
  75.                 {"fmp",           RC_S },
  76.                 {"cur_frame",     RC_S },
  77.  
  78.                 {"aistate",       RC_S },
  79.                 {"aistate_time",  RC_S },
  80.                 {"targetable",    RC_C }
  81.  
  82.                   };
  83.   
  84. long game_object::get_var_by_name(char *name, int &error)
  85. {
  86.   error=0;
  87.   int i=0;
  88.   for (;i<TOTAL_OBJECT_VARS;i++)
  89.   {
  90.     if (!strcmp(object_descriptions[i].name,name))
  91.       return get_var(i);
  92.   }
  93.  
  94.   for (i=0;i<figures[otype]->tiv;i++)
  95.   {
  96.     if (!strcmp(lstring_value(symbol_name(figures[otype]->vars[i])),name))
  97.     {
  98.       return lvars[figures[otype]->var_index[i]];
  99. /*      lisp_object_var *cobj=(lisp_object_var *)symbol_value(figures[otype]->vars[i]);
  100.       character_type *t=figures[otype];
  101.       int number=cobj->number;
  102.       if (t->tiv<=number || !t->vars[number])
  103.       {
  104.     lbreak("access : variable does not exsist for this class\n");
  105.     return 0;
  106.       }
  107.       return lvars[t->var_index[number]];*/
  108.     }
  109.   }
  110.   error=1;
  111.   return 0;
  112. }
  113.  
  114. int game_object::set_var_by_name(char *name, long value)
  115. {
  116.   int i=0;
  117.   for (;i<TOTAL_OBJECT_VARS;i++)
  118.   {
  119.     if (!strcmp(object_descriptions[i].name,name))
  120.     {
  121.       set_var(i,value);
  122.       return 1;
  123.     }
  124.   }
  125.   for (i=0;i<figures[otype]->tiv;i++)
  126.     if (!strcmp(lstring_value(symbol_name(figures[otype]->vars[i])),name))
  127.     {
  128.       lvars[figures[otype]->var_index[i]]=value;
  129.       return 1;
  130.     }
  131.   return 0;
  132. }
  133.  
  134.  
  135. char *simple_object::var_name(int x)
  136. {
  137.   return object_descriptions[x].name;
  138. }
  139.  
  140. int simple_object::var_type(int x)
  141. {
  142.   return object_descriptions[x].type;
  143. }
  144.  
  145.  
  146. void simple_object::set_var(int xx, ulong v)
  147. {
  148.   switch (xx)
  149.   {
  150.     case 0 : set_fade_dir(v); break;
  151.     case 1 : set_frame_dir(v); break;
  152.     case 2 : direction=v; break;
  153.     case 3 : set_gravity(v); break;
  154.     case 4 : set_fade_count(v); break;
  155.     case 5 : set_fade_max(v); break;
  156.     case 6 : active=v;break;
  157.     case 7 : set_flags(v); break;
  158.     case 8 : set_aitype(v); break;
  159.     case 9 : set_xvel(v); break;
  160.  
  161.     case 10 : set_fxvel(v); break;
  162.     case 11 : set_yvel(v); break;
  163.     case 12 : set_fyvel(v); break;
  164.     case 13 : set_xacel(v); break;
  165.     case 14 : set_fxacel(v); break;
  166.  
  167.     case 15 : set_yacel(v); break;
  168.     case 16 : set_fyacel(v); break;
  169.     case 17 : x=v; break;
  170.     case 18 : set_fx(v); break;
  171.     case 19 : y=v; break;
  172.  
  173.     case 20 : set_fy(v); break;
  174.     case 21 : set_hp(v); break;
  175.     case 22 : set_mp(v); break;
  176.     case 23 : set_fmp(v); break;
  177.  
  178.     case 24 : current_frame=v;  break;
  179.     case 25 : set_aistate(v); break;
  180.  
  181.     case 26 : set_aistate_time(v); break;
  182.     case 27 : set_targetable(v); break;
  183.   }
  184. }
  185.  
  186. long simple_object::get_var(int xx)
  187. {
  188.   switch (xx)
  189.   {
  190.     case 0 : return fade_dir(); break;
  191.     case 1 : return frame_dir(); break;
  192.     case 2 : return direction; break;
  193.     case 3 : return gravity(); break;
  194.     case 4 : return fade_count(); break;
  195.     case 5 : return fade_max(); break;
  196.     case 6 : return active; break;
  197.     case 7 : return flags(); break;
  198.     case 8 : return aitype(); break;
  199.     case 9 : return xvel(); break;
  200.     case 10 : return fxvel(); break;
  201.  
  202.     case 11 : return yvel(); break;
  203.     case 12 : return fyvel(); break;
  204.  
  205.     case 13 : return xacel(); break;
  206.     case 14 : return fxacel(); break;
  207.  
  208.     case 15 : return yacel(); break;
  209.     case 16 : return fyacel(); break;
  210.  
  211.     case 17 : return x; break;
  212.     case 18 : return fx(); break;
  213.  
  214.     case 19 : return y; break;
  215.     case 20 : return fy(); break;
  216.  
  217.     case 21 : return hp(); break;
  218.     case 22 : return mp(); break;
  219.     case 23 : return fmp(); break;
  220.  
  221.     case 24 : return current_frame;  break;
  222.     case 25 : return aistate(); break;
  223.     case 26 : return aistate_time(); break;
  224.     case 27 : return targetable();
  225.   }
  226.   return 0;
  227. }
  228.  
  229.  
  230.  
  231.  
  232. int RC_type_size(int type)
  233. {
  234.   switch (type)
  235.   {
  236.     case RC_C : 
  237.     { return 1; } break;
  238.     case RC_S : 
  239.     { return 2; } break;
  240.     case RC_L : 
  241.     { return 4; } break;
  242.   }        
  243.   CHECK(0);
  244.   return 1;
  245. } 
  246.  
  247. void game_object::reload_notify()
  248. {
  249.   void *ns=figures[otype]->get_fun(OFUN_RELOAD);  
  250.   if (ns)
  251.   {
  252.     game_object *o=current_object;
  253.     current_object=this;
  254.  
  255.     void *m=mark_heap(TMP_SPACE);
  256.     eval_function((lisp_symbol *)ns,NULL);
  257.     restore_heap(m,TMP_SPACE);
  258.  
  259.     current_object=o;
  260.   }
  261. }
  262.  
  263. void game_object::next_sequence()
  264. {
  265.   void *ns=figures[otype]->get_fun(OFUN_NEXT_STATE);
  266.   if (ns)
  267.   {  
  268.     current_object=this;
  269.     void *m=mark_heap(TMP_SPACE);
  270.     void *ret=eval_function((lisp_symbol *)ns,NULL);
  271.     restore_heap(m,TMP_SPACE);
  272.   } else
  273.   {
  274.     switch (state)
  275.     {
  276.       case dieing : 
  277.       { set_state(dead); } break;
  278.  
  279.       case end_run_jump :
  280.       {
  281.     set_state(running);
  282.       } break;
  283.       case dead :
  284.       case run_jump :
  285.       case run_jump_fall :
  286.       case running :
  287.       { set_state(state); } break;
  288.       case start_run_jump :
  289.       { 
  290.     set_yvel(get_ability(type(),jump_yvel));
  291.     if (xvel()>0)
  292.         set_xvel(get_ability(type(),jump_xvel));
  293.     else if (xvel()<0)
  294.         set_xvel(-get_ability(type(),jump_xvel));
  295.     set_xacel(0);
  296.     set_fxacel(0);
  297.     set_gravity(1);      
  298.     set_state(run_jump);
  299.       } break;
  300.  
  301.       case flinch_up :
  302.       case flinch_down :
  303.       {
  304.     if (gravity())
  305.     {
  306.       if (has_sequence(end_run_jump))
  307.         set_state(end_run_jump);
  308.       else set_state(stopped);
  309.     } else set_state(stopped);
  310.       } break;
  311.  
  312.       
  313.       default :
  314.       { set_state(stopped); } break;
  315.     }
  316.   }
  317.  
  318. }
  319.  
  320.  
  321.  
  322. game_object::~game_object()
  323. {
  324.   if (lvars) jfree(lvars);
  325.   clean_up();
  326. }
  327.  
  328. void game_object::add_power(int amount)  
  329. { 
  330.   int max_power=lnumber_value(symbol_value(l_max_power));  
  331.   int n=mp()+amount;
  332.   if (n<0) n=0;
  333.   if (n>max_power) n=max_power;
  334.   set_mp(n);
  335. }
  336.  
  337. void game_object::add_hp(int amount)
  338. {
  339.   if (controller() && controller()->god) return ;
  340.   int max_hp=lnumber_value(symbol_value(l_max_hp));  
  341.   int n=hp()+amount;
  342.   if (n<0) n=0;
  343.   if (n>max_hp)
  344.     n=max_hp;
  345.   set_hp(n);
  346. }
  347.  
  348. int game_object::can_morph_into(int type)
  349. {
  350.   if (type!=otype && mp()>=figures[type]->morph_power)
  351.     return 1;
  352.   else return 0;
  353. }
  354.  
  355. void game_object::morph_into(int type, void (*stat_fun)(int), int anneal, int frames)
  356. {
  357.   set_morph_status(new morph_char(this,type,stat_fun,anneal,frames));
  358.   otype=type;
  359.   set_state(stopped);
  360. }
  361.  
  362. void game_object::draw_above(view *v)
  363. {
  364.   long x1,y1,x2,y2,sy1,sy2,sx,i;
  365.   picture_space(x1,y1,x2,y2);    
  366.  
  367.   the_game->game_to_mouse(x1,y1,v,sx,sy2);
  368.   if (sy2>=v->cy1)
  369.   {
  370.     long draw_to=y1-(sy2-v->cy1),tmp=x;
  371.     current_level->foreground_intersect(x,y1,tmp,draw_to);     
  372.     the_game->game_to_mouse(x1,draw_to,v,i,sy1);     // calculate sy1
  373.  
  374.     sy1=max(v->cy1,sy1);
  375.     sy2=min(v->cy2,sy2);
  376.     trans_image *p=picture();
  377.     
  378.     for (i=sy1;i<=sy2;i++)
  379.       p->put_scan_line(screen,sx,i,0);  
  380.   }  
  381. }
  382.  
  383. int game_object::push_range()
  384. {
  385.   return get_ability(otype,push_xrange);
  386. }
  387.  
  388. int game_object::decide()
  389. {
  390.   if (figures[otype]->get_fun(OFUN_AI))
  391.   {
  392.     int old_aistate;
  393.     old_aistate=aistate();
  394.  
  395.     current_object=this;
  396.     void *m=mark_heap(TMP_SPACE);
  397.  
  398.     time_marker *prof1;
  399.     if (profiling())
  400.       prof1=new time_marker;
  401.  
  402.     Cell *ret=(Cell *)eval_function((lisp_symbol *)figures[otype]->get_fun(OFUN_AI),NULL);
  403.     if (profiling())
  404.     {
  405.       time_marker now;
  406.       profile_add_time(this->otype,now.diff_time(prof1));
  407.       delete prof1;
  408.     }
  409.  
  410.     restore_heap(m,TMP_SPACE);
  411.  
  412.     if (keep_ai_info())
  413.     {
  414.       if (aistate()!=old_aistate)
  415.       set_aistate_time(0);
  416.       else set_aistate_time(aistate_time()+1);    
  417.     }
  418.     if (!NILP(ret)) return 1;
  419.     else return 0;
  420.   }
  421.   else move(0,0,0);
  422.   return 1;
  423. }
  424.  
  425. int game_object::can_hurt(game_object *who)     // collision checking will ask first to see if you
  426. {
  427.   int is_attacker=current_level->is_attacker(this);  
  428.   // it's you against them!  Damage only if it you are attacking or they are attacking you
  429.   // I.E. don't let them hurt themselves, this can change if you over-ride this virtual function
  430.  
  431.   if (who->hurtable() && (is_attacker || current_level->is_attacker(who) || hurt_all()))
  432.     return 1;
  433.   else return 0;  
  434. }
  435.  
  436. void game_object::note_attack(game_object *whom)
  437. {
  438.   return ;   // nevermind
  439. }
  440.  
  441. void game_object::do_flinch(game_object *from)
  442. {
  443.   if (jrandom(2) && has_sequence(flinch_down))
  444.     set_state(flinch_down);
  445.   else if (has_sequence(flinch_up))
  446.     set_state(flinch_up);
  447. }
  448.  
  449.    
  450. void game_object::do_damage(int amount, game_object *from, long hitx, long hity, 
  451.                 long push_xvel, long push_yvel) 
  452. {
  453.  
  454.   void *d=figures[otype]->get_fun(OFUN_DAMAGE);  
  455.   if (d)
  456.   {
  457.     void    *am, *frm, *hx, *hy, *px, *py;  
  458.     game_object *o=current_object;
  459.     current_object=this;
  460.  
  461.     void *m=mark_heap(TMP_SPACE);
  462.  
  463.     am=new_cons_cell();
  464.     l_ptr_stack.push(&am);
  465.  
  466.     ((cons_cell *)am)->car=new_lisp_number(amount);   
  467.  
  468.     frm=new_cons_cell();
  469.     l_ptr_stack.push(&frm);
  470.  
  471.     ((cons_cell *)frm)->car=new_lisp_pointer(from);
  472.  
  473.     hx=new_cons_cell();
  474.     l_ptr_stack.push(&hx);
  475.  
  476.     ((cons_cell *)hx)->car=new_lisp_number(hitx);
  477.  
  478.     hy=new_cons_cell();
  479.     l_ptr_stack.push(&hy);
  480.     ((cons_cell *)hy)->car=new_lisp_number(hity);
  481.  
  482.     px=new_cons_cell();
  483.     l_ptr_stack.push(&px);
  484.     ((cons_cell *)px)->car=new_lisp_number(push_xvel);
  485.  
  486.     py=new_cons_cell();
  487.     l_ptr_stack.push(&py);
  488.     ((cons_cell *)py)->car=new_lisp_number(push_yvel);
  489.  
  490.  
  491.     ((cons_cell *)am)->cdr=frm;
  492.     ((cons_cell *)frm)->cdr=hx;
  493.     ((cons_cell *)hx)->cdr=hy;
  494.     ((cons_cell *)hy)->cdr=px;
  495.     ((cons_cell *)px)->cdr=py;
  496.  
  497.     time_marker *prof1;
  498.     if (profiling())
  499.       prof1=new time_marker;
  500.  
  501.     eval_user_fun((lisp_symbol *)d,am);
  502.     if (profiling())
  503.     {
  504.       time_marker now;
  505.       profile_add_time(this->otype,now.diff_time(prof1));
  506.       delete prof1;
  507.     }
  508.  
  509.  
  510.     l_ptr_stack.pop(6);
  511.    
  512.     restore_heap(m,TMP_SPACE);
  513.  
  514.     current_object=o;
  515.   } else damage_fun(amount,from,hitx,hity,push_xvel,push_yvel);
  516. #ifdef SCADALISP
  517.   ENDLOCAL();
  518. #endif
  519. }
  520.  
  521. void game_object::damage_fun(int amount, game_object *from, long hitx, long hity, 
  522.                 long push_xvel, long push_yvel) 
  523. { 
  524.   if (!hurtable() || !alive()) return ;
  525.  
  526.   add_hp(-amount);
  527.   set_flags(flags()|FLAG_JUST_HIT);
  528.   do_flinch(from);
  529.  
  530.   
  531.   set_xvel(xvel()+push_xvel);
  532.   if (push_yvel<0 && !gravity())
  533.     set_gravity(1);
  534.   set_yvel(yvel()+push_yvel);
  535.  
  536.   view *c=controller();
  537.   if (c && hp()<=0)
  538.   {
  539.     view *v=from->controller();
  540.     if (v) v->kills++;                       // attack from another player?
  541.     else if (from->total_objects()>0)
  542.     {
  543.       v=from->get_object(0)->controller();   // weapon from another player?
  544.       if (v && v!=c) v->kills++;
  545.       else
  546.       {
  547.     v=c;                                 // sucide
  548.     if (v) v->kills--;
  549.       }
  550.     }
  551.   }
  552. }
  553.      
  554.  
  555.  
  556. int game_object::facing_attacker(int attackerx)
  557. { 
  558.   return ((attackerx<x && direction<0) || (attackerx>=x && direction>0)); 
  559.  
  560. }
  561.  
  562.  
  563. void game_object::picture_space(long &x1, long &y1,long &x2, long &y2)
  564. {
  565.   int xc=x_center(),w=picture()->width(),h=picture()->height();  
  566.   if (direction>0)
  567.     x1=x-xc;  
  568.   else x1=x-(w-xc-1);  
  569.   x2=x1+w-1;
  570.   y1=y-h+1;
  571.   y2=y;  
  572. }
  573.  
  574.  
  575. int game_object::next_picture()
  576. {
  577.   int ret=1;
  578.   if (frame_dir()>0)
  579.   {
  580.     if (!current_sequence()->next_frame(current_frame))
  581.     {
  582.       next_sequence();
  583.       ret=0;
  584.     }
  585.   }
  586.   else 
  587.   {
  588.     if (!current_sequence()->last_frame(current_frame))
  589.     {
  590.       next_sequence();
  591.       ret=0;
  592.     }
  593.   }
  594.   frame_advance();
  595.   return ret;
  596. }
  597.  
  598.  
  599. long game_object::x_center()
  600. {
  601.   return current_sequence()->x_center(current_frame);   
  602. }
  603.  
  604.  
  605. void game_object::draw()
  606. {
  607.   if (figures[otype]->get_fun(OFUN_DRAW))
  608.   {
  609.     current_object=this;
  610.  
  611.     void *m=mark_heap(TMP_SPACE);
  612.     time_marker *prof1;
  613.     if (profiling())
  614.       prof1=new time_marker;
  615.  
  616.     eval_function((lisp_symbol *)figures[otype]->get_fun(OFUN_DRAW),NULL);
  617.     if (profiling())
  618.     {
  619.       time_marker now;
  620.       profile_add_time(this->otype,now.diff_time(prof1));
  621.       delete prof1;
  622.     }
  623.  
  624.  
  625.  
  626.     restore_heap(m,TMP_SPACE);
  627.  
  628.   } else drawer();
  629. }
  630.  
  631.  
  632. void game_object::map_draw()
  633. {
  634.   if (figures[otype]->get_fun(OFUN_MAP_DRAW))
  635.   {
  636.     current_object=this;
  637.  
  638.     void *m=mark_heap(TMP_SPACE);
  639.     time_marker *prof1;
  640.     if (profiling())
  641.       prof1=new time_marker;
  642.  
  643.     eval_function((lisp_symbol *)figures[otype]->get_fun(OFUN_MAP_DRAW),NULL);
  644.     if (profiling())
  645.     {
  646.       time_marker now;
  647.       profile_add_time(this->otype,now.diff_time(prof1));
  648.       delete prof1;
  649.     }
  650.  
  651.     restore_heap(m,TMP_SPACE);
  652.  
  653.   }
  654. }
  655.  
  656. void game_object::draw_trans(int count, int max)
  657. {
  658.   trans_image *cpict=picture();
  659.   cpict->put_fade(screen,
  660.           (direction<0 ? x-(cpict->width()-x_center()-1) : x-x_center())-current_vxadd,
  661.           y-cpict->height()+1-current_vyadd,
  662.           count,max,
  663.           color_table,the_game->current_palette());
  664. }
  665.  
  666.  
  667. void game_object::draw_tint(int tint_id)
  668. {
  669.   trans_image *cpict=picture();
  670.   if (fade_count())      
  671.     cpict->put_fade_tint(screen,
  672.                (direction<0 ? x-(cpict->width()-x_center()-1) : x-x_center())-current_vxadd,
  673.                y-cpict->height()+1-current_vyadd,
  674.                fade_count(),fade_max(),
  675.                cash.ctint(tint_id)->data,
  676.                color_table,the_game->current_palette());
  677.  
  678.  
  679.   else
  680.     cpict->put_remaped(screen,
  681.                (direction<0 ? x-(cpict->width()-x_center()-1) : x-x_center())-current_vxadd,
  682.                y-cpict->height()+1-current_vyadd,
  683.                cash.ctint(tint_id)->data);
  684. }
  685.  
  686.  
  687. void game_object::draw_double_tint(int tint_id, int tint2)
  688. {
  689.   trans_image *cpict=picture();
  690.   if (fade_count())      
  691.     cpict->put_fade_tint(screen,
  692.                (direction<0 ? x-(cpict->width()-x_center()-1) : x-x_center())-current_vxadd,
  693.                y-cpict->height()+1-current_vyadd,
  694.                fade_count(),fade_max(),
  695.                cash.ctint(tint_id)->data,
  696.                color_table,the_game->current_palette());
  697.  
  698.  
  699.   else
  700.     cpict->put_double_remaped(screen,
  701.                (direction<0 ? x-(cpict->width()-x_center()-1) : x-x_center())-current_vxadd,
  702.                y-cpict->height()+1-current_vyadd,
  703.                cash.ctint(tint_id)->data,
  704.                cash.ctint(tint2)->data);
  705. }
  706.  
  707.  
  708.  
  709. void game_object::draw_predator()
  710. {
  711.   trans_image *cpict=picture();
  712.   cpict->put_predator(screen,
  713.              (direction<0 ? x-(cpict->width()-x_center()-1) : x-x_center())-current_vxadd,
  714.              y-cpict->height()+1-current_vyadd);
  715.             
  716. }
  717.  
  718. void game_object::drawer()
  719. {
  720.   trans_image *cpict;
  721.  
  722.   if (morph_status())
  723.   {
  724.     morph_status()->draw(this,current_view);
  725.     if (morph_status()->frames_left()<1)
  726.       set_morph_status(NULL);
  727.   }
  728.   else
  729.   {
  730.     view *v=controller();
  731.  
  732.     if (fade_count())      
  733.       draw_trans(fade_count(),fade_max());
  734.     else
  735.     {
  736.       trans_image *cpict=picture();
  737.       cpict->put_image(screen,
  738.                (direction<0 ? x-(cpict->width()-x_center()-1) : x-x_center())-current_vxadd,
  739.                y-cpict->height()+1-current_vyadd);
  740.     }
  741.   }
  742. }
  743.  
  744. game_object *game_object::try_move(long x, long y, long &xv, long &yv, int checks)
  745. {
  746.   if (xv || yv)  // make sure they are suggesting movement
  747.   {    
  748.     game_object *who1=NULL,*who2=NULL;      // who did we intersect?  
  749.     long x2,y2,h;  
  750.  
  751.     if (checks&1)
  752.     {      
  753.       x2=x+xv;
  754.       y2=y+yv;    
  755.       current_level->foreground_intersect(x,y,x2,y2);
  756.       if (!stoppable())
  757.         who1=current_level->boundary_setback(this,x,y,x2,y2);
  758.       else
  759.         who1=current_level->all_boundary_setback(this,x,y,x2,y2);  
  760.       xv=x2-x;
  761.       yv=y2-y;
  762.     }
  763.     
  764.  
  765.     if (checks&2)
  766.     {      
  767.       h=picture()->height();    
  768.       x2=x+xv;    
  769.       y2=y-h+1+yv; 
  770.       current_level->foreground_intersect(x,y-h+1,x2,y2);
  771.       if (!stoppable())
  772.         who2=current_level->all_boundary_setback(this,x,y-h+1,x2,y2);    
  773.       else
  774.         who2=current_level->boundary_setback(this,x,y-h+1,x2,y2);
  775.       xv=x2-x;
  776.       yv=y2-y+h-1;  
  777.     }
  778.         
  779.     if (who2) return who2;
  780.     else return who1;
  781.   }
  782.   else return NULL;  
  783. }
  784.  
  785. void *game_object::float_tick()  // returns 1 if you hit something, 0 otherwise
  786. {
  787.   long ret=0;
  788.   if (hp()<=0)
  789.   {
  790.     if (state!=dead)
  791.     {
  792.       set_xacel(0);
  793.       set_fxacel(0);
  794.  
  795.       if (has_sequence(dieing))
  796.       {      
  797.     if (state!=dieing)
  798.     {
  799.       set_state(dieing);
  800.       set_xvel(0);
  801.     }
  802.       } else 
  803.       { set_xvel(0); 
  804.     set_fxvel(0);
  805.     if (has_sequence(dead))
  806.           set_state(dead); 
  807.     else return 0;
  808.       }
  809.     } 
  810.   }
  811.  
  812.   long fxv=sfxvel()+sfxacel(),fyv=sfyvel()+sfyacel();
  813.   long xv=xvel()+xacel()+(fxv>>8),yv=yvel()+yacel()+(fyv>>8);
  814.  
  815.   if (xv!=xvel() || yv!=yvel())   // only store vel's if changed so we don't increase object size
  816.   {
  817.     set_xvel(xv);
  818.     set_yvel(yv);
  819.   }
  820.  
  821.   if (fxv!=sfxvel() || fyv!=sfyvel())
  822.   {
  823.     set_fxvel(fxv&0xff);
  824.     set_fyvel(fyv&0xff);
  825.   }
  826.  
  827.  
  828.   if (fxv || fyv || xv || yv)   // don't even try if there is no velocity
  829.   {
  830.     long nx=x,ny=y;
  831.     long ffx=fx()+sfxvel(),ffy=fy()+sfyvel();
  832.     long nxv=xvel()+(ffx>>8);
  833.     long nyv=yvel()+(ffy>>8);
  834.     set_fx(ffx&0xff);
  835.     set_fy(ffy&0xff);
  836.     
  837.     long old_nxv=nxv,old_nyv=nyv;
  838.     game_object *hit_object=try_move(x,y,nxv,nyv,3);   // now find out what velocity is safe to use
  839.     
  840. /*    if (get_cflag(CFLAG_STOPPABLE))
  841.     {
  842.       game_object *r=current_level->boundary_setback(exclude,x,y,nxv,nyv,1);
  843.       if (r) hit_object=r;
  844.     }*/
  845.  
  846.     x+=nxv;
  847.     y+=nyv;
  848.     if (old_nxv!=nxv || old_nyv!=nyv)
  849.     {
  850.       long lx=last_tile_hit_x,ly=last_tile_hit_y;
  851.       stop();
  852.       if (old_nxv==0)
  853.       {
  854.     if (old_nyv>0) ret|=BLOCKED_DOWN;
  855.     else if (old_nyv<0) ret|=BLOCKED_UP;
  856.       } else if (old_nyv==0)
  857.       {
  858.     if (old_nxv>0) ret|=BLOCKED_RIGHT;
  859.     else if (old_nxv<0) ret|=BLOCKED_LEFT;
  860.       } else
  861.       {
  862.     long tx=(old_nxv>0 ? 1 : -1),ty=0;
  863.     try_move(x,y,tx,ty,3);
  864.     if (!tx)     
  865.       ret|=(old_nxv>0 ? BLOCKED_RIGHT : BLOCKED_LEFT);    
  866.     else tx=0;
  867.  
  868.     ty=(old_nyv>0 ? 1 : -1);
  869.     try_move(x,y,tx,ty,3);
  870.     if (!ty)     
  871.       ret|=(old_nyv>0 ? BLOCKED_DOWN : BLOCKED_UP);
  872.     
  873.     if (!ret)
  874.       ret|=(old_nyv>0 ? BLOCKED_DOWN : BLOCKED_UP) | (old_nxv>0 ? BLOCKED_RIGHT : BLOCKED_LEFT);
  875.  
  876.       }
  877.  
  878.       void *rlist=NULL;   // return list
  879.       p_ref r1(rlist);
  880.  
  881.       if (hit_object)
  882.       {
  883.     push_onto_list(new_lisp_pointer(hit_object),rlist);
  884.     push_onto_list(l_object,rlist);
  885.       } else
  886.       {
  887.     push_onto_list(new_lisp_number(ly),rlist);
  888.     push_onto_list(new_lisp_number(lx),rlist);
  889.     push_onto_list(l_tile,rlist);
  890.       }
  891.       push_onto_list(new_lisp_number(ret),rlist);
  892.  
  893.       return rlist;
  894.     } else return true_symbol;
  895.   }
  896.   return true_symbol;
  897. }
  898.  
  899. int game_object::tick()      // returns blocked status
  900. {
  901.   int blocked=0;
  902.  
  903.   long xt=0,yt=2;
  904.   try_move(x,y-2,xt,yt,1);    // make sure we are not falling through the floor
  905.   y=y-2+yt;
  906.   
  907.   if (flags()&FLAG_JUST_BLOCKED)
  908.     set_flags(flags()-FLAG_JUST_BLOCKED);
  909.  
  910.   if (gravity() && !floating())
  911.   {
  912.     int fya;
  913.     if (yacel()>=0)
  914.       fya=sfyacel()+200;
  915.     else
  916.       fya=sfyacel()-200;
  917.  
  918.     set_yacel(yacel()+(fya>>8));
  919.     set_fyacel(fya&255);
  920.   }
  921.   
  922.   // first let's move the guy acording to his physics
  923.   long xa=xacel(),ya=yacel(),fxa=sfxacel(),fya=sfyacel();
  924.   if (xa || ya || fxa || fya)
  925.   {
  926.     int fxv=sfxvel(),fyv=sfyvel();
  927.     fxv+=fxa;  fyv+=fya;    
  928.     long xv=xvel()+xa+(fxv>>8); 
  929.     set_xvel(xvel()+xa+(fxv>>8));
  930.     set_yvel(yvel()+ya+(fyv>>8));
  931.     set_fxvel(fxv&0xff);
  932.     set_fyvel(fyv&0xff);
  933.   }
  934.   
  935.   // check to see if this advancement causes him to collide with objects
  936.   long old_vy=yvel(),old_vx=xvel();  // save the correct veloicties
  937.  
  938.   if (old_vx || old_vy)
  939.   {
  940.     int up=0;
  941.     if (yvel()<=0)  // if we are going up or a strait across check up and down
  942.     up=2;
  943.     long xv=xvel(),yv=yvel();
  944.     game_object *h=try_move(x,y,xv,yv,1|up);       // now find out what velocity is safe to use
  945.     set_xvel(xv);
  946.     set_yvel(yv);
  947.     x+=xv;
  948.     y+=yv;
  949.  
  950.     if (h && stoppable()) return BLOCKED_LEFT|BLOCKED_RIGHT;
  951.  
  952.     if (xv!=old_vx || yv!=old_vy)     // he collided with something
  953.     {          
  954.       if (gravity())                         // was he going up or down?
  955.       {                           
  956.     long fall_xv=0,old_fall_vy,fall_vy;
  957.     old_fall_vy=fall_vy=old_vy-yvel();             // make sure he gets all of his yvel
  958.     try_move(x,y,fall_xv,fall_vy,1|up);
  959.     if (old_vy>0 && fall_vy<old_fall_vy)       // he was trying to fall, but he hit the ground
  960.     {
  961.       if (old_vy>0)    
  962.       {
  963.         blocked|=BLOCKED_DOWN;
  964.         
  965.         if (!xvel() && has_sequence(end_run_jump))      
  966.         {
  967.           set_xvel(old_vx);
  968.           set_state(end_run_jump);
  969.         }
  970.         else set_state(stopped);      
  971.       }
  972.       else blocked|=BLOCKED_UP;
  973.  
  974.  
  975.       if (state==run_jump_fall)
  976.       {
  977.         if (has_sequence(running))
  978.         set_state(running);
  979.         else
  980.         {
  981.           stop_x();
  982.           set_state(stopped);
  983.         }
  984.       }
  985.       else
  986.       {
  987.         set_yacel(0);
  988.         set_fyacel(0);
  989.         set_yvel(0);
  990.         set_fyvel(0);
  991.         set_gravity(0);
  992.       }
  993.  
  994.     } else 
  995.     {
  996.       if (old_vy!=0)
  997.       {
  998.         long testx=old_vx<0 ? -1 : 1,testy=0;    // see if we were stopped left/right
  999.                                                      // or just up down
  1000.         try_move(x,y,testx,testy,1|up);
  1001.         if (testx==0)                           // blocked left/right, set flag
  1002.         {
  1003.           if (old_vx<0)
  1004.             blocked|=BLOCKED_LEFT;
  1005.           else
  1006.             blocked|=BLOCKED_RIGHT;
  1007.         }
  1008.         else if (old_vy<0)
  1009.           blocked|=BLOCKED_UP;
  1010.         else if (old_vy>0)
  1011.           blocked|=BLOCKED_DOWN;
  1012.  
  1013.       } else if (old_vx<0)   // we can skip left/right test because player wasn't moving up/down
  1014.             blocked|=BLOCKED_LEFT;
  1015.       else
  1016.             blocked|=BLOCKED_RIGHT;
  1017.  
  1018.       set_xvel(0);
  1019.       set_fxvel(0);
  1020.       if (old_vy<0 && fall_vy>0)        
  1021.       {
  1022.         set_yvel(yvel()+fall_vy);
  1023.       } else set_yvel(yvel()+fall_vy);
  1024.     }      
  1025.     y+=fall_vy;            
  1026.       }    
  1027.       else                  // see if we can make him 'climb' the hill
  1028.       {
  1029.     long ox=x,oy=y;       // rember orginal position in case climb doesn't work
  1030.  
  1031.     long climb_xvel=0,climb_yvel=-5;        // try to move up one pixel to step over the 
  1032.     try_move(x,y,climb_xvel,climb_yvel,3);  // jutting polygon line
  1033.     y+=climb_yvel;
  1034.  
  1035.     climb_xvel=old_vx-xvel();
  1036.     climb_yvel=-(abs(climb_xvel));        // now try 45 degree slope
  1037.     try_move(x,y,climb_xvel,climb_yvel,3);
  1038.  
  1039.     if (abs(climb_xvel)>0)  // see if he got further by climbing
  1040.     {
  1041.       blocked=blocked&(~(BLOCKED_LEFT|BLOCKED_RIGHT));
  1042.       x+=climb_xvel;
  1043.       y+=climb_yvel;
  1044.  
  1045.       set_xvel(xvel()+climb_xvel);
  1046.       set_yvel(0);          
  1047.       set_fyvel(0);
  1048.       
  1049.       // now put him back on the ground          
  1050.       climb_yvel=abs(climb_xvel)+5;               // plus one to put him back on the ground
  1051.       climb_xvel=0;
  1052.       try_move(x,y,climb_xvel,climb_yvel,1);
  1053.       if (climb_yvel)
  1054.           y+=climb_yvel;
  1055.     }
  1056.     else             
  1057.     {    
  1058.       if (old_vx<0)
  1059.           blocked|=BLOCKED_LEFT;
  1060.       else
  1061.           blocked|=BLOCKED_RIGHT;
  1062.       set_state(stopped);      // nope, musta hit a wall, stop the poor fella
  1063.       x=ox;
  1064.       y=oy;    
  1065.     }
  1066.     
  1067.       }
  1068.       
  1069.       if (xvel()!=old_vx && state!=run_jump_fall && state!=end_run_jump)
  1070.       {
  1071.     set_xacel(0); 
  1072.     set_fxacel(0);
  1073.       }
  1074.     }
  1075.   }
  1076.      
  1077.   if (yacel()==0 && !gravity())       // he is not falling, make sure he can't
  1078.   {
  1079.     long nvx=0,nvy=yvel()+12;  // check three pixels below for ground
  1080.     try_move(x,y,nvx,nvy,1); 
  1081.     if (nvy>11)                    // if he falls more than 2 pixels, then he falls
  1082.     {
  1083.       if (state!=run_jump_fall)      // make him fall
  1084.       {       
  1085.         if (has_sequence(run_jump_fall))
  1086.           set_state(run_jump_fall);
  1087.         set_gravity(1);
  1088.       }
  1089.     } else if (nvy)   // if he fells less than 3 pixels then let him descend 'hills'
  1090.     {      
  1091.       y+=nvy;
  1092.       blocked|=BLOCKED_DOWN;      
  1093.     }    
  1094.   }
  1095.   return blocked;
  1096. }
  1097.  
  1098. void game_object::defaults()
  1099. {
  1100.   set_state(state);
  1101.   if (otype!=0xffff)
  1102.   {
  1103.     int s=get_ability(otype,start_hp);
  1104.     if (s!=default_simple.hp())
  1105.       set_hp(s);
  1106.   }
  1107. }
  1108.  
  1109. void game_object::frame_advance()
  1110. {
  1111.   int ad=current_sequence()->get_advance(current_frame);
  1112.   if (ad && current_level)
  1113.   {
  1114.     long xv;
  1115.     if (direction>0) xv=ad; else xv=-ad;
  1116.     long yv=0;
  1117.     try_move(x,y,xv,yv,3);
  1118.     x+=xv;
  1119.   }   
  1120. }
  1121.  
  1122. void game_object::set_state(character_state s, int frame_direction)
  1123. {
  1124.   if (has_sequence(s))
  1125.     state=s;
  1126.   else state=stopped;
  1127.  
  1128.   current_frame=0;  
  1129.   if (frame_direction!=1)
  1130.     set_frame_dir(frame_direction); 
  1131.  
  1132.   frame_advance();
  1133. }
  1134.  
  1135.  
  1136. game_object *create(int type, long x, long y, int skip_constructor, int aitype)
  1137. {
  1138.   game_object *g=new game_object(type,skip_constructor);
  1139.   g->x=x; g->y=y; g->last_x=x; g->last_y=y;
  1140.   if (aitype)
  1141.     g->set_aitype(aitype);
  1142.   if (figures[type]->get_fun(OFUN_CONSTRUCTOR) && !skip_constructor)
  1143.   {
  1144.     game_object *o=current_object;
  1145.     current_object=g;    
  1146.  
  1147.     void *m=mark_heap(TMP_SPACE);
  1148.  
  1149.     time_marker *prof1;
  1150.     if (profiling())
  1151.       prof1=new time_marker;
  1152.  
  1153.     eval_function((lisp_symbol *)figures[type]->get_fun(OFUN_CONSTRUCTOR),NULL);
  1154.     if (profiling())
  1155.     {
  1156.       time_marker now;
  1157.       profile_add_time(type,now.diff_time(prof1));
  1158.       delete prof1;
  1159.     }
  1160.  
  1161.  
  1162.  
  1163.     restore_heap(m,TMP_SPACE);
  1164.  
  1165.     current_object=o;
  1166.   }
  1167.   return g;
  1168. }
  1169.  
  1170. int base_size()
  1171. {
  1172.   return 1+  
  1173.          1*8+
  1174.      2*5+
  1175.      4*7;
  1176. }
  1177.  
  1178. int game_object::size()
  1179. {
  1180.   return base_size();
  1181. }
  1182.  
  1183.  
  1184.  
  1185. int game_object::move(int cx, int cy, int button)
  1186. {  
  1187.   int ret=0;
  1188.  
  1189.   if (figures[otype]->get_fun(OFUN_MOVER))      // is a lisp move function defined?
  1190.   {
  1191.     void *lcx,*lcy,*lb;
  1192.  
  1193.     game_object *o=current_object;
  1194.     current_object=this;
  1195.  
  1196.  
  1197.     // make a list of the parameters, and call the lisp function
  1198.     lcx=new_cons_cell();
  1199.     l_ptr_stack.push(&lcx);
  1200.     ((cons_cell *)lcx)->car=new_lisp_number(cx);
  1201.  
  1202.     lcy=new_cons_cell();
  1203.     l_ptr_stack.push(&lcy);
  1204.     ((cons_cell *)lcy)->car=new_lisp_number(cy);
  1205.  
  1206.     lb=new_cons_cell();
  1207.     l_ptr_stack.push(&lb);
  1208.     ((cons_cell *)lb)->car=new_lisp_number(button);
  1209.  
  1210.  
  1211.     ((cons_cell *)lcx)->cdr=lcy;
  1212.     ((cons_cell *)lcy)->cdr=lb;
  1213.  
  1214.     void *m=mark_heap(TMP_SPACE);
  1215.  
  1216.     time_marker *prof1;
  1217.     if (profiling())
  1218.       prof1=new time_marker;
  1219.  
  1220.     void *r=eval_function((lisp_symbol *)figures[otype]->get_fun(OFUN_MOVER),
  1221.               (void *)lcx);
  1222.     if (profiling())
  1223.     {
  1224.       time_marker now;
  1225.       profile_add_time(this->otype,now.diff_time(prof1));
  1226.       delete prof1;
  1227.     }
  1228.  
  1229.     restore_heap(m,TMP_SPACE);
  1230.  
  1231.     l_ptr_stack.pop(3);
  1232.     if (item_type(r)!=L_NUMBER)
  1233.     {
  1234.       lprint(r);
  1235.       lbreak("Object %s did not return a number from it's mover function!\n"
  1236.          "It should return a number to indicate it's blocked status to the\n"
  1237.          "ai function.",object_names[otype]);    
  1238.     }
  1239.     ret|=lnumber_value(r);
  1240.     current_object=o;
  1241.   }
  1242.   else ret|=mover(cx,cy,button);    
  1243.  
  1244.   return ret;
  1245. }
  1246.  
  1247. int game_object::mover(int cx, int cy, int button)  // return false if the route is blocked
  1248. {
  1249.   if (hp()<=0) 
  1250.     return tick();
  1251.  
  1252.   if (flinch_state(state))                    // flinching? don't move
  1253.     cx=cy=button=0;
  1254.     
  1255.  
  1256.   if (cx)          // x movement suggested?
  1257.   {      
  1258.     if (state==stopped)   // see if started moving
  1259.     {   
  1260.       if (has_sequence(running))
  1261.       {
  1262.     if (cx>0)
  1263.     {
  1264.       direction=1;
  1265.           set_xvel(get_ability(type(),run_top_speed));
  1266.     }
  1267.     else
  1268.     {
  1269.       direction=-1;
  1270.       set_xacel(-get_ability(type(),run_top_speed));
  1271.     }
  1272.     set_state(running);
  1273.       }
  1274.     } else if (state==run_jump || state==run_jump_fall)
  1275.     {
  1276.       if (cx>0)
  1277.       {
  1278.     direction=1;
  1279.     set_xacel(get_ability(type(),start_accel));           // set the appropriate accel
  1280.       } else
  1281.       {
  1282.     direction=-1;
  1283.     set_xacel(-get_ability(type(),start_accel));           // set the appropriate accel
  1284.       }      
  1285.     }
  1286.     else 
  1287.     {
  1288.       // turn him around if he pressed the other way, he is not walking so a fast turn
  1289.       // is needed, don't go through the turn sequence
  1290.       if ((cx>0  && direction<0) || (cx<0 && direction>0))
  1291.         direction=-direction;      
  1292.     } 
  1293.   }         // not pressing left or right, so slow down or stop
  1294.   else if (!gravity() && state!=start_run_jump)
  1295.   {    
  1296.     long stop_acel;
  1297.     if (xvel()<0)                                    // he was going left
  1298.     {
  1299.       stop_acel=get_ability(type(),stop_accel);    // find out how fast he can slow down
  1300.       if (xvel()+stop_acel>=0)                       // if this acceleration is enough to stop him
  1301.       {
  1302.     stop_x();
  1303.     if (!gravity())    
  1304.       set_state(stopped);      
  1305.       } else { set_xacel(stop_acel); }
  1306.     } else if (xvel()>0)
  1307.     {
  1308.       stop_acel=-get_ability(type(),stop_accel);
  1309.       if (xvel()+stop_acel<=0)
  1310.       {
  1311.     stop_x();
  1312.     if (!gravity())
  1313.       set_state(stopped);
  1314.       } else set_xacel(stop_acel);
  1315.     } else if (!gravity())                // don't stop in the air
  1316.     { 
  1317.       set_xacel(0);
  1318.       set_fxacel(0);
  1319.       // Check to see if we should go to stop state 
  1320.       if (state==running)
  1321.         set_state(stopped);
  1322.     }   
  1323.   }    
  1324.   
  1325.  
  1326. /*  if (state==still_jump || state==still_jump_fall || state==end_still_jump)
  1327.   {
  1328.     set_xacel(0);
  1329.     set_fxacel(0);
  1330.     if (xvel()>0) set_xvel(get_ability(type(),jump_top_speed));
  1331.     else if (xvel()<0) set_xvel(-get_ability(type(),jump_top_speed));
  1332.   } else if (state==run_jump || state==run_jump_fall || state==end_run_jump)
  1333.   {
  1334.     set_xacel(0);
  1335.     set_fxacel(0);
  1336.     if (xvel()>0) set_xvel(get_ability(type(),jump_top_speed));
  1337.     else if (xvel()<0) set_xvel(-get_ability(type(),jump_top_speed));
  1338.   } */
  1339.   
  1340.   // see if the user said to jump
  1341.   if (cy<0 && !floating() && !gravity())
  1342.   {
  1343.     set_gravity(1);      
  1344.     set_yvel(get_ability(type(),jump_yvel));
  1345. //    if (cx && has_sequence(run_jump))
  1346.       set_state(run_jump);
  1347.     if (xvel()!=0)
  1348.       if (direction>0)
  1349.         set_xvel(get_ability(type(),jump_top_speed));
  1350.       else
  1351.         set_xvel(-get_ability(type(),jump_top_speed));
  1352.     set_xacel(0);
  1353.  
  1354.  
  1355. /*    if (state==stopped)  
  1356.     {
  1357.       if (cx && has_sequence(start_run_jump))
  1358.         set_state(start_run_jump);
  1359.       else if (has_sequence(start_still_jump))
  1360.         set_state(start_still_jump);                
  1361.       else 
  1362.       {
  1363.  
  1364.       }
  1365.     }
  1366.     else if (state==running && has_sequence(run_jump))
  1367.     {
  1368.       set_state(run_jump);
  1369.       set_yvel(get_ability(type(),jump_yvel));
  1370.       set_gravity(1);      
  1371.     }    
  1372.     else if (state==walking || state==turn_around)  // if walking check to see if has a
  1373.     {
  1374.       if (has_sequence(start_still_jump))
  1375.         set_state(start_still_jump);    
  1376.       else
  1377.       {
  1378.         set_yvel(get_ability(type(),jump_yvel));
  1379.         set_gravity(1);      
  1380.         if (has_sequence(run_jump))
  1381.           set_state(run_jump);
  1382.       }
  1383.     }    */
  1384.   }
  1385.  
  1386.  
  1387.  
  1388.   if (state==run_jump && yvel()>0)
  1389.     set_state(run_jump_fall);
  1390.     
  1391.  
  1392.  
  1393. //  if (state!=end_still_jump && state!=end_run_jump)
  1394.   {    
  1395.     if (cx>0)
  1396.       set_xacel(get_ability(type(),start_accel));
  1397.     else if (cx<0)
  1398.       set_xacel(-get_ability(type(),start_accel));
  1399.   }  
  1400.   
  1401.   // make sure they are not going faster than their maximum speed
  1402.   int top_speed;
  1403.   if (state==stopped || state==end_run_jump)
  1404.     top_speed=get_ability(type(),walk_top_speed);
  1405.   else if (state==running)
  1406.     top_speed=get_ability(type(),run_top_speed);    
  1407.   else if (state==run_jump || state==run_jump_fall || state==start_run_jump)
  1408.   {
  1409.     top_speed=get_ability(type(),jump_top_speed);      
  1410.     if (!cx) top_speed=0;
  1411.   }
  1412.   else top_speed=1000;
  1413.     
  1414.       
  1415.   if (abs(xvel()+xacel())>top_speed)
  1416.   {    
  1417.     if (xacel()<0) set_xacel(-top_speed-xvel());
  1418.     else set_xacel(top_speed-xvel());
  1419.   }  
  1420.     
  1421.   character_state old_state=state;
  1422.   int old_frame=current_frame;    
  1423.   int tick_stat=tick();
  1424.  
  1425.   // if he started to jump and slammed into a wall then make sure he stays in this state
  1426.   // so he can finish the jump
  1427.   if (!tick_stat && (old_state==start_run_jump))
  1428.   {
  1429.     set_state(old_state);
  1430.     current_frame=old_frame;
  1431.     next_picture();    
  1432.   }
  1433.     
  1434.   return tick_stat;
  1435.     
  1436. }
  1437.  
  1438.  
  1439.  
  1440.  
  1441. game_object *game_object::bmove(int &whit, game_object *exclude)
  1442. {
  1443.  
  1444.   // first let's move the guy acording to his physics
  1445.   long xa=xacel(),ya=yacel(),fxa=sfxacel(),fya=sfyacel();
  1446.   if (xa || ya || fxa || fya)
  1447.   {
  1448.     int fxv=sfxvel(),fyv=sfyvel();
  1449.     fxv+=fxa;  fyv+=fya;    
  1450.     long xv=xvel()+xa+(fxv>>8); 
  1451.     set_xvel(xvel()+xa+(fxv>>8));
  1452.     set_yvel(yvel()+ya+(fyv>>8));
  1453.     set_fxvel(fxv&0xff);
  1454.     set_fyvel(fyv&0xff);
  1455.   }
  1456.   
  1457.   long ox2,oy2;
  1458.  
  1459.   long nx=x+xvel(),nfx=fx()+fxvel(),ny=y+yvel(),nfy=fy()+fyvel();
  1460.   nx+=nfx>>8;
  1461.   ny+=nfy>>8;
  1462.  
  1463.  
  1464.   // check to see if this advancement causes him to collide with objects
  1465.   ox2=nx;
  1466.   oy2=ny;  // save the correct veloicties
  1467.   
  1468.   current_level->foreground_intersect(x,y,nx,ny);  // first see how far we can travel
  1469.   game_object *ret=current_level->all_boundary_setback(exclude,x,y,nx,ny);
  1470.   x=nx;
  1471.   y=ny;
  1472.   set_fx(nfx&0xff);
  1473.   set_fy(nfy&0xff);
  1474.   if (ret)
  1475.   {
  1476.     if (!ret->hurtable())   // object is not hurtable, return as if hit wall.
  1477.     { whit=1;
  1478.       return NULL;
  1479.     } else
  1480.     return ret;
  1481.   }
  1482.   else
  1483.   {
  1484.     whit=(nx!=ox2 || ny!=oy2);
  1485.     return NULL;
  1486.   }
  1487. }
  1488.  
  1489.  
  1490.  
  1491. int object_to_number_in_list(game_object *who, object_node *list)
  1492. {
  1493.   int x=1;
  1494.   while (list) 
  1495.   { 
  1496.     if (who==list->me) return x; 
  1497.     else list=list->next;
  1498.     x++;
  1499.   }
  1500.   return 0;
  1501. }
  1502.  
  1503. game_object *number_to_object_in_list(long x, object_node *list)
  1504. {
  1505.   if (!x) return NULL; x--;
  1506.   while (x && list) { list=list->next; x--; }
  1507.   if (list) return list->me;
  1508.   else return NULL;
  1509. }
  1510.  
  1511.  
  1512. void delete_object_list(object_node *first)
  1513. {
  1514.   while (first)
  1515.   {
  1516.     object_node *n=first;
  1517.     first=first->next;
  1518.     delete n;
  1519.   }
  1520. }
  1521.  
  1522.  
  1523. long object_list_length(object_node *list)
  1524. {
  1525.   long x=0;
  1526.   while (list) { list=list->next; x++; }
  1527.   return x;
  1528.   
  1529. }
  1530.  
  1531.  
  1532.  
  1533. game_object::game_object(int Type, int load) 
  1534. { 
  1535.   if (Type<0xffff)
  1536.   {
  1537.     int t=figures[Type]->tv;
  1538.     if (t)
  1539.     {
  1540.       lvars=(long *)jmalloc(t*4,"object vars");
  1541.       memset(lvars,0,t*4);
  1542.     }
  1543.     else lvars=NULL;
  1544.   } else lvars=NULL;
  1545.  
  1546.   otype=Type; 
  1547.   if (!load) defaults(); 
  1548. }
  1549.  
  1550.  
  1551. int game_object::reduced_state()
  1552. {
  1553.   long x=0;
  1554.   for (int i=0;i<figures[otype]->ts;i++)
  1555.   {
  1556.     if (i==state) return x;
  1557.       else
  1558.     if (figures[otype]->seq[i]) x++;
  1559.   }
  1560.   return 0;
  1561. }
  1562.  
  1563.  
  1564. void game_object::change_aitype(int new_type)
  1565. {
  1566.   set_aitype(new_type);
  1567.   if (otype<0xffff)
  1568.   {
  1569.     void *f=figures[otype]->get_fun(OFUN_CHANGE_TYPE);  
  1570.     if (f) 
  1571.     {
  1572.       game_object *o=current_object;
  1573.       current_object=(game_object *)this;
  1574.  
  1575.       time_marker *prof1;
  1576.       if (profiling())
  1577.         prof1=new time_marker;
  1578.  
  1579.       eval_user_fun((lisp_symbol *)f,NULL);
  1580.  
  1581.       if (profiling())
  1582.       {
  1583.     time_marker now;
  1584.     profile_add_time(this->otype,now.diff_time(prof1));
  1585.     delete prof1;
  1586.       }
  1587.  
  1588.  
  1589.       current_object=o;
  1590.     }
  1591.   }
  1592. }
  1593.  
  1594.  
  1595. void game_object::change_type(int new_type)
  1596. {
  1597.   if (lvars) jfree(lvars);     // free old variable
  1598.  
  1599.   if (otype<0xffff)
  1600.   {
  1601.     int t=figures[new_type]->tv;
  1602.     if (t)
  1603.     {
  1604.       lvars=(long *)jmalloc(t*4,"object vars");
  1605.       memset(lvars,0,t*4);
  1606.     }
  1607.     else lvars=NULL;
  1608.   } else return;
  1609.   otype=new_type;
  1610.  
  1611.   if (figures[new_type]->get_fun(OFUN_CONSTRUCTOR))
  1612.   {
  1613.     game_object *o=current_object;
  1614.     current_object=this;    
  1615.  
  1616.     void *m=mark_heap(TMP_SPACE);
  1617.  
  1618.     time_marker *prof1;
  1619.     if (profiling())
  1620.       prof1=new time_marker;
  1621.  
  1622.     eval_function((lisp_symbol *)figures[new_type]->get_fun(OFUN_CONSTRUCTOR),NULL);
  1623.     if (profiling())
  1624.     {
  1625.       time_marker now;
  1626.       profile_add_time(otype,now.diff_time(prof1));
  1627.       delete prof1;
  1628.     }
  1629.  
  1630.  
  1631.     restore_heap(m,TMP_SPACE);
  1632.  
  1633.     current_object=o;
  1634.   }  
  1635. }
  1636.